/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package restaurante.cgt;

import java.util.ArrayList;
import java.util.List;
import restaurante.cdp.*;
import restaurante.cdp.enuns.Tamanho;
import restaurante.cdp.enuns.TipoFuncionario;
import restaurante.cdp.enuns.TipoProduto;
import restaurante.cgd.*;
import restaurante.util.persistencia.DAOFactory;



/**
 *
 * @author Gabriel
 */
public class AplCadastroInterno {
    private static AplCadastroInterno instance = null;
    
    
    private CaixaDAO apCaixaDAO = (CaixaDAO) DAOFactory.getInstance().obterDAO(Caixa.class);
    private CozinheiroDAO apCozinheiroDAO = (CozinheiroDAO) DAOFactory.getInstance().obterDAO(Cozinheiro.class);
    private GarcomDAO apGarcomDAO = (GarcomDAO) DAOFactory.getInstance().obterDAO(Garcom.class);
    private MotoboyDAO apMotoboyDAO = (MotoboyDAO) DAOFactory.getInstance().obterDAO(Motoboy.class);
    private TelefonistaDAO apTelefonistaDAO = (TelefonistaDAO) DAOFactory.getInstance().obterDAO(Telefonista.class);
    private ProdutoDAO apProdutoDAO = (ProdutoDAO) DAOFactory.getInstance().obterDAO(Produto.class);
    
    

    private AplCadastroInterno() {
    }

    /**
     * Obtém uma instância da aplicação. Implementação do padrão Singleton.
     */
    public static AplCadastroInterno getInstance() {
        if (instance == null) {
                instance = new AplCadastroInterno();
        }
        return instance;
    }
    
    /**
     * Inclui um caixa
     * @param args
     * @return O caixa incluido
     * @throws Exception 
     */
    public Caixa incluirCaixa(List<Object> args) throws Exception
    {
        System.out.println("AplCadastroInterno - incluirCaixa");
        Caixa obj = new Caixa();
        obj.setNome((String) args.get(0));
        obj.setCpf(Long.valueOf((String) args.get(1)));
        obj.setSalario(Double.valueOf((String) args.get(2)));
        obj.setTipoFuncionario(TipoFuncionario.CAIXA);
        apCaixaDAO.salvar(obj);
        return obj;
    }
    
    /**
     * Altera um caixa
     * @param componentes
     * @param caixa
     * @throws Exception 
     */
    
    public void alterarCaixa(List componentes, Caixa caixa) throws Exception
    {
        System.out.println("AplCadastroInterno - alterarCaixa");
        Caixa c = apCaixaDAO.obter(Caixa.class, caixa.getId());
        c.setNome((String) componentes.get(0));
        c.setCpf(Long.valueOf((String) componentes.get(1)));
        c.setSalario(Double.valueOf((String) componentes.get(2)));
        apCaixaDAO.salvar(c);
    }
    
    /**
     * Obtem todos os caixas cadastrados
     * @return Uma lista de caixas
     * @throws Exception 
     */
    public List<Caixa> obterCaixas() throws Exception
    {
        System.out.println("AplCadastroInterno - obterCaixas");
        return apCaixaDAO.obter(Caixa.class);
    }
    /**
     * Apaga um caixa
     * @param caixa
     * @throws Exception 
     */
    public void apagarCaixa(Caixa caixa) throws Exception
    {
        System.out.println("AplCadastroInterno - apagarCaixa");
        apCaixaDAO.excluir(caixa);
    }
    
    /**
     * Incluir um cozinheiro
     * @param args
     * @return O cozinheiro cadastrado
     * @throws Exception 
     */
    public Cozinheiro incluirCozinheiro(List<Object> args) throws Exception
    {
        System.out.println("AplCadastroInterno - incluirCozinheiro");
        Cozinheiro obj = new Cozinheiro();
        obj.setNome((String) args.get(0));
        obj.setCpf(Long.valueOf((String) args.get(1)));
        obj.setSalario(Double.valueOf((String) args.get(2)));
        obj.setTipoFuncionario(TipoFuncionario.COZINHEIRO);
        apCozinheiroDAO.salvar(obj); 
        return obj;
    }
    
    /**
     * Altera um cozinheiro
     * @param componentes
     * @param cozinheiro
     * @throws Exception 
     */
    public void alterarCozinheiro(List componentes, Cozinheiro cozinheiro) throws Exception
    {
        System.out.println("AplCadastroInterno - alterarCozinheiro");
        Cozinheiro c = apCozinheiroDAO.obter(Cozinheiro.class, cozinheiro.getId());
        c.setNome((String) componentes.get(0));
        c.setCpf(Long.valueOf((String) componentes.get(1)));
        c.setSalario(Double.valueOf((String) componentes.get(2)));      
        apCozinheiroDAO.salvar(c);
    }
    
    /**
     * Obter todos os cozinheiros cadastrados
     * @return Um lista com os cozinheiros
     * @throws Exception 
     */
    public List<Cozinheiro> obterCozinheiros() throws Exception
    {
        System.out.println("AplCadastroInterno - obterCozinheiros");
        return apCozinheiroDAO.obter(Cozinheiro.class);
    }
    
    /**
     * Apaga um cozinheiro
     * @param cozinheiro
     * @throws Exception 
     */
    public void apagarCozinheiro(Cozinheiro cozinheiro) throws Exception
    {
        System.out.println("AplCadastroInterno - apagarCaixa");
        apCozinheiroDAO.excluir(cozinheiro);
    }
    
    /**
     * Inclui um garcom
     * @param args
     * @return O garcom cadastrado
     * @throws Exception 
     */
    public Garcom incluirGarcom(List<Object> args) throws Exception
    {
        System.out.println("AplCadastroInterno - incluirGarcom");
        Garcom obj = new Garcom();
        obj.setNome((String) args.get(0));
        obj.setCpf(Long.valueOf((String) args.get(1)));
        obj.setSalario(Double.valueOf((String) args.get(2)));
        obj.setTipoFuncionario(TipoFuncionario.GARÇOM);
        apGarcomDAO.salvar(obj);
        return obj;
    }
    
    /**
     * Altera um garcom
     * @param componentes
     * @param garcom
     * @throws Exception 
     */
    public void alterarGarcom(List componentes, Garcom garcom) throws Exception
    {
        System.out.println("AplCadastroInterno - alterarGarcom");
        Garcom g = apGarcomDAO.obter(Garcom.class, garcom.getId());
        g.setNome((String) componentes.get(0));
        g.setCpf(Long.valueOf((String) componentes.get(1)));
        g.setSalario(Double.valueOf((String) componentes.get(2)));      
        apGarcomDAO.salvar(g);
    }
    
    /**
     * Obtem todos os garcons
     * @return Uma lista de garons cadastrados
     * @throws Exception 
     */
    public List<Garcom> obterGarcons() throws Exception
    {
        System.out.println("AplCadastroInterno - obterGarcons");
        return apGarcomDAO.obter(Garcom.class);
    }
    
    /**
     * Apaga um garcom
     * @param garcom
     * @throws Exception 
     */
    public void apagarGarcom(Garcom garcom) throws Exception
    {
        System.out.println("AplCadastroInterno - apagarGarcom");
        apGarcomDAO.excluir(garcom);
    }
    
    /**
     * Inclui um motoboy
     * @param args
     * @return O motoboy cadastrado
     * @throws Exception 
     */
    public Motoboy incluirMotoboy(List<Object> args) throws Exception
    {
        System.out.println("AplCadastroInterno - incluirMotoboy");
        Motoboy obj = new Motoboy();
        obj.setNome((String) args.get(0));
        obj.setCpf(Long.valueOf((String) args.get(1)));
        obj.setSalario(Double.valueOf((String) args.get(2)));
        obj.setTipoFuncionario(TipoFuncionario.MOTOBOY);
        apMotoboyDAO.salvar(obj);
        return obj;
    }
    
    /**
     * Altera um Motoboy
     * @param componentes
     * @param motoboy
     * @throws Exception 
     */
    public void alterarMotoboy(List componentes, Motoboy motoboy) throws Exception
    {
        System.out.println("AplCadastroInterno - aletarMotoboy");
        Motoboy m = apMotoboyDAO.obter(Motoboy.class, motoboy.getId());
        m.setNome((String) componentes.get(0));
        m.setCpf(Long.valueOf((String) componentes.get(1)));
        m.setSalario(Double.valueOf((String) componentes.get(2)));      
        apMotoboyDAO.salvar(m);
    }
    
    /**
     * Obtem todos os motoboys cadastrados
     * @return Um lista com os motboys
     * @throws Exception 
     */
    public List<Motoboy> obterMotoboys() throws Exception
    {
        System.out.println("AplCadastroInterno - obterMotoboys");
        return apMotoboyDAO.obter(Motoboy.class);
    }
    
    /**
     * Apaga um motoboy
     * @param motoboy
     * @throws Exception 
     */
    public void apagarMotoboy(Motoboy motoboy) throws Exception
    {
        System.out.println("AplCadastroInterno - apagarMotoboy");
        apMotoboyDAO.excluir(motoboy);
    }
    
    /**
     * Inclui uma Telefonista
     * @param args
     * @return A telefonista cadastrada 
     * @throws Exception 
     */
    public Telefonista incluirTelefonista(List<Object> args) throws Exception
    {
        System.out.println("AplCadastroInterno - incluirTelefonista");
        Telefonista obj = new Telefonista();
        obj.setNome((String) args.get(0));
        obj.setCpf(Long.valueOf((String) args.get(1)));
        obj.setSalario(Double.valueOf((String) args.get(2)));
        obj.setTipoFuncionario(TipoFuncionario.TELEFONISTA);
        apTelefonistaDAO.salvar(obj);
        return obj;
    }
    
    /**
     * Altera uma Telefonista
     * @param componentes
     * @param telefonista
     * @throws Exception 
     */
    public void alterarTelefonista(List componentes, Telefonista telefonista) throws Exception
    {
        System.out.println("AplCadastroInterno - alterarTelefonista");
        Telefonista t = apTelefonistaDAO.obter(Telefonista.class, telefonista.getId());
        t.setNome((String) componentes.get(0));
        t.setCpf(Long.valueOf((String) componentes.get(1)));
        t.setSalario(Double.valueOf((String) componentes.get(2)));      
        apTelefonistaDAO.salvar(t);
    }
    
    /**
     * Obtem todas as telefonistas cadastradas
     * @return Uma lista com as telefonistas
     * @throws Exception 
     */
    public List<Telefonista> obterTelefonistas() throws Exception
    {
        System.out.println("AplCadastroInterno - obterTelefonistas");
        return apTelefonistaDAO.obter(Telefonista.class);
    }
    
    /**
     * Apaga uma Telefonista
     * @param telefonista
     * @throws Exception 
     */
    public void apagarTelefonista(Telefonista telefonista) throws Exception
    {
        System.out.println("AplCadastroInterno - apagarTelefonista");
        apTelefonistaDAO.excluir(telefonista);
    }
    
    /**
     * Inclui um novo funcionario(Caixa, Cozinheiro, Garcom, Motoboy, Telefonista)
     * @param args
     * @return O funcionario cadastrado
     * @throws Exception 
     */
    public Funcionario incluirFuncionario(List<Object> args) throws Exception {
        System.out.println("AplCadastroInterno - incluirFuncionario");
        switch((TipoFuncionario) args.get(3))
        {
            case CAIXA:
            {
                return incluirCaixa(args);             
            }
            case COZINHEIRO:
            {
                return incluirCozinheiro(args);
            }
            case GARÇOM:
            {
                return incluirGarcom(args);
            }
            case MOTOBOY:
            {
                return incluirMotoboy(args);
            }
            case TELEFONISTA:
            {
                return (Funcionario) incluirTelefonista(args);
            }
        }
        return null;
    }
    
    /**
     * Altera um funcionario(Caixa, Cozinheiro, Garcom, Motoboy, Telefonista)
     * @param args
     * @param funcionario
     * @throws Exception 
     */
    public void alterarFuncionario(List args, Funcionario funcionario) throws Exception
    {
        System.out.println("AplCadastroInterno - aletarFuncionario");
        switch(funcionario.getTipoFuncionario())
        {
            case CAIXA:
            {
                alterarCaixa(args, (Caixa) funcionario);             
            }
            case COZINHEIRO:
            {
                alterarCozinheiro(args, (Cozinheiro) funcionario); 
            }
            case GARÇOM:
            {
                alterarGarcom(args, (Garcom) funcionario); 
            }
            case MOTOBOY:
            {
               alterarMotoboy(args, (Motoboy) funcionario); 
            }
            case TELEFONISTA:
            {
                alterarTelefonista(args, (Telefonista) funcionario); 
            }
        }
    }
    
    /**
     * Obtem todos os funcionarios(Caixa, Cozinheiro, Garcom, Motoboy, Telefonista)
     * @return Uma lista com os funcionarios
     * @throws Exception 
     */
    public List<Funcionario> obterFuncionarios() throws Exception
    {
        System.out.println("AplCadastroInterno - obterFuncionarios");
        List<Funcionario> l = new ArrayList<>();
        l.addAll(obterCaixas());
        l.addAll(obterCozinheiros());
        l.addAll(obterGarcons());
        l.addAll(obterMotoboys());
        l.addAll(obterTelefonistas());
        return l;
    }
    
    
    /**
     * Apaga um funcionario(Caixa, Cozinheiro, Garcom, Motoboy, Telefonista)
     * @param funcionario
     * @throws Exception 
     */
    public void apagarFuncionario(Funcionario funcionario) throws Exception
    {
        System.out.println("AplCadastroInterno - apagarFuncionario");
        switch(funcionario.getTipoFuncionario())
        {
            case CAIXA:
            {
               apagarCaixa((Caixa) funcionario);           
            }
            case COZINHEIRO:
            {
                apagarCozinheiro((Cozinheiro) funcionario);
                
            }
            case GARÇOM:
            {
                apagarGarcom((Garcom) funcionario); 
            }
            case MOTOBOY:
            {
               apagarMotoboy((Motoboy) funcionario); 
            }
            case TELEFONISTA:
            {
                apagarTelefonista((Telefonista) funcionario); 
            }
        }
    }
    
    /**
     * Inclui um novo produto
     * @param args
     * @return o produto cadastrado
     * @throws Exception 
     */
    public Produto incluirProduto(List<Object> args) throws Exception {
        System.out.println("AplCadastroInterno - incluirProduto");
        Produto p = new Produto();
        p.setNome((String) args.get(0));
        p.setCusto(Double.valueOf(((String) args.get(1))));
        p.setValor(Double.valueOf((String) args.get(2)));
        p.setTam(((Tamanho) args.get(3)));
        p.setTipo((TipoProduto) args.get(4));
        p.setTempoPreparo(Double.valueOf((String) args.get(5)));
        p.setSabor((String) args.get(6));
        
        apProdutoDAO.salvar(p);
        
        return p;
		
    }
    
    /**
     * Apaga um produto
     * @param produto
     * @throws Exception 
     */
    public void apagarProduto(Produto produto) throws Exception {
        System.out.println("AplCadastroInterno - apagarProduto");
        apProdutoDAO.excluir(produto);
    }
    
    /**
     * Obtem todos os produtos cadastrados
     * @return Um lista com os produtos
     * @throws Exception 
     */
    public List<Produto> obterProdutos() throws Exception {
        System.out.println("AplCadastroInterno - obterProdutos");
        return apProdutoDAO.obter(Produto.class);
    }
    
    /**
     * Obtem todos os produtos cadastrados pelo tipo
     * @param tipo
     * @return Uma lista com os produtos
     */
    public List<Produto> obterProdutos(TipoProduto tipo) {
        System.out.println("AplCadastroInterno - obterProdutos(Passando tipo)");
        return ((ProdutoDAOJPA)apProdutoDAO).obter(tipo);
    }
    
    /**
     * Altera um produto
     * @param componentes
     * @param produto
     * @throws Exception 
     */
    public void alterarProduto(List componentes, Produto produto) throws Exception {
        System.out.println("AplCadastroInterno - alterarProduto");
        Produto p =  apProdutoDAO.obter(Produto.class, produto.getId());
        
        p.setNome((String) componentes.get(0));
        p.setCusto(Double.valueOf(((String) componentes.get(1))));
        p.setValor(Double.valueOf((String) componentes.get(2)));
        p.setTam(((Tamanho) componentes.get(3)));
        p.setTipo((TipoProduto) componentes.get(4));
        p.setTempoPreparo(Double.valueOf((String) componentes.get(5)));
        p.setSabor((String) componentes.get(6));
        
        apProdutoDAO.salvar(p);
        
    }

    
    
    
    
}
